home *** CD-ROM | disk | FTP | other *** search
/ Power CD / Power CD ATARI-Rechner Lieben.iso / UTILITY / LSRC_222 / UTIL.S < prev    next >
Encoding:
Text File  |  1993-07-28  |  11.1 KB  |  697 lines
  1.  
  2.             export    FTimeToULong
  3.             export    ilong
  4.             export    itime
  5.             export    ProcInd
  6.             export    Bgetc
  7.             export    Bputc
  8.             export    block_crc
  9.             export    mkcrc
  10.             export    crc_getc
  11.             export    mksum
  12.             export    stpcpy
  13.             export    strcpy
  14.             export    strchr
  15.             export    strcmp
  16.             export    strlen
  17.             export    flg_n
  18.             export    blkcnt
  19.             export    RotInd
  20.             export    make_tree
  21.             export    sortptr
  22.             export    count_len
  23.             export    get_fname
  24.             export    backpath
  25.             export    star
  26.  
  27.             import    _filbuf
  28.             import    crctbl
  29.             import    crc
  30.             import    error
  31.             import    outfname
  32.             import    infname
  33.             import  proc_ind
  34.             import    freq
  35.             import    heap
  36.             import    heapsize
  37.             import    make_len
  38.             import    len_cnt
  39.             import    left
  40.             import    right
  41.             import    len
  42.  
  43.  
  44. RDERR        equ        13
  45. WTERR        equ        14
  46.  
  47.  
  48. ilong:        move.l    (a0),d0
  49.             ror.w    #8,d0
  50.             swap    d0
  51.             ror.w    #8,d0
  52.             move.l    d0,(a0)
  53.             rts
  54.  
  55.  
  56. itime:        move.l    (a0),d0
  57.             ror.w    #8,d0
  58.             swap    d0
  59.             ror.w    #8,d0
  60.             swap    d0
  61.             move.l    d0,(a0)
  62.             rts
  63.  
  64.  
  65. FTimeToULong:
  66.             move.l    (a0),d0
  67.             swap    d0
  68.             rts
  69.  
  70.  
  71. ProcInd:    move.b    flg_n(pc),d0
  72.             subq.b    #1,d0
  73.             beq.b    _procexit
  74.             bmi.b    _proc_star
  75.  
  76.             subq.b    #1,d0
  77.             beq        proc_ind
  78.  
  79.             lea.l    RotInd(pc),a0
  80.             move.w    (a0),d1
  81.             move.b    rot(pc,d1.w),d2
  82.  
  83.             addq.w    #1,d1
  84.             and.w    #3,d1
  85.             move.w    d1,(a0)
  86.  
  87.             pea        (a2)
  88.             move.w    d2,-(sp)
  89.             move.w    #2,-(sp)
  90.             trap    #1
  91.  
  92.             pea        $20008
  93.             trap    #1
  94.             addq.w    #8,sp
  95.             move.l    (sp)+,a2
  96.  
  97.             rts
  98.  
  99. _proc_star:    subq.w    #1,blkcnt
  100.             bmi.b    _procexit
  101.  
  102.             pea        (a2)
  103.             move.w    star(PC),-(sp)
  104.             move.w    #2,-(sp)
  105.             trap    #1
  106.             addq.w    #4,sp
  107.             move.l    (sp)+,a2
  108.  
  109. _procexit:    rts
  110.  
  111. RotInd:        dc.w    0
  112. rot:        dc.b    '-/|\'
  113.  
  114.             EVEN
  115.  
  116. Bgetc:        subq.l    #1,(a0)+    ; _cnt
  117.             bmi.b    _empty
  118.  
  119.             move.l    (a0),a1        ; _ptr
  120.             moveq.l    #0,d0
  121.             move.b    (a1)+,d0
  122.             move.l    a1,(a0)
  123.             rts
  124.  
  125. _empty:        subq.w    #4,a0
  126.             bsr        _filbuf
  127.             rts
  128.  
  129.  
  130. block_crc:    movem.w    d0/d4-d5,-(sp)
  131.  
  132.             move.w    #8,d5
  133.  
  134.             lea.l    crc,a1
  135.             move.w    (a1)+,d1    ; a1 -> crctbl
  136.  
  137.             moveq.l    #16,d2
  138.             cmp.l    d2,d0
  139.             blt        end_crc
  140.  
  141.             lsr.l    #4,d0
  142.             subq.l    #1,d0
  143.  
  144. bwhile_crc:    REPT    16
  145.             moveq.l    #0,d4
  146.             move.b    (a0)+,d4
  147.             eor.b    d1,d4
  148.             add.w    d4,d4
  149.             move.w    0(a1,d4.w),d2
  150.             lsr.w    d5,d1
  151.             eor.w    d2,d1
  152.             ENDM
  153.             dbra    d0,bwhile_crc
  154.  
  155.             moveq.l    #15,d0
  156.             and.w    (sp),d0
  157.  
  158. end_crc:    subq.w    #1,d0
  159.             bmi.s    crc_set
  160.  
  161. fwhile_crc:    moveq.l    #0,d4
  162.             move.b    (a0)+,d4
  163.             eor.b    d1,d4
  164.             add.w    d4,d4
  165.             move.w    0(a1,d4.w),d2
  166.             lsr.w    d5,d1
  167.             eor.w    d2,d1
  168.             dbra    d0,fwhile_crc
  169.  
  170. crc_set:    move.w    d1,-(a1)    ; crc
  171.  
  172.             addq.w    #2,sp
  173.             move.w    (sp)+,d4
  174.             move.w    (sp)+,d5
  175.             rts
  176.  
  177.  
  178. mkcrc:        lea     crctbl+512,a0
  179.             move.w    #255,d0
  180.             move.l    d3,a1
  181.             move.w    #$A001,d3
  182.  
  183. crc_loop:    move.w    d0,d1
  184.             moveq.l    #7,d2
  185.  
  186. j_loop:        lsr.w    #1,d1
  187.             bcc.s    next_j
  188.             eor.w    d3,d1
  189. next_j:        dbra    d2,j_loop
  190.  
  191.             move.w    d1,-(a0)
  192.             dbra    d0,crc_loop
  193.  
  194.             move.l    a1,d3
  195.             rts
  196.  
  197.  
  198. crc_getc:    subq.l    #1,(a0)+    ; _cnt
  199.             bmi.b    _get_empty
  200.  
  201.             move.l    (a0),a1    ; _ptr
  202.             moveq.l    #0,d0
  203.             move.b    (a1)+,d0
  204.             move.l    a1,(a0)
  205.  
  206. _crc:        lea.l    crc,a0
  207.             move.w    (a0)+,d2
  208.             move.w    d2,d1
  209.             lsr.w    #8,d1
  210.             eor.w    d0,d2
  211.             and.w    #$FF,d2
  212.             add.w    d2,d2
  213.             move.w    (a0,d2.w),d2    ; crctbl
  214.             eor.w    d1,d2
  215.             move.w    d2,-(a0)        ; crc
  216.             rts
  217.  
  218. _get_empty:    subq.w    #4,a0
  219.             pea        (a0)
  220.             bsr        _filbuf
  221.  
  222.             tst.w    d0
  223.             bmi.b    _eof
  224.  
  225.             addq.w    #4,sp
  226.             bra.b    _crc
  227.  
  228. _eof:        move.l    (sp)+,a0
  229.             move.w    12(a0),d1    ; _flag
  230.             and.w    #$4000,d1
  231.             bne.b    _get_error
  232.             rts
  233.  
  234. _get_error:    move.l    infname,a0
  235.             moveq.l    #RDERR,d0
  236.             moveq.l    #-1,D1
  237.             bra        error
  238.  
  239.  
  240. mksum:        subq.w    #1,d0
  241.             moveq.l    #0,d1
  242.             addq.w    #2,a0
  243.  
  244. _sum:        add.b    (a0)+,d1
  245.             dbra    d0,_sum
  246.             move.w    d1,d0
  247.             rts
  248.  
  249.  
  250. stpcpy:        move.l    a1,d0
  251.             beq.b    _no_source
  252.  
  253. _stpcpy:    REPT    23
  254.             move.b    (a1)+,(a0)+
  255.             beq.b    _stp_back
  256.             ENDM
  257.  
  258.             move.b    (a1)+,(a0)+
  259.             bne.b    _stpcpy
  260.  
  261. _stp_back:    subq.w    #1,a0
  262.             rts
  263.  
  264. _no_source:    clr.b    (a0)
  265.             rts
  266.  
  267.  
  268. strcpy:        move.l    a1,d0
  269.             beq.b    _no_source
  270.  
  271.             move.l    a0,d0
  272.  
  273. _strcpy:    REPT    23
  274.             move.b    (a1)+,(a0)+
  275.             beq.b    _str_exit
  276.             ENDM
  277.  
  278.             move.b    (a1)+,(a0)+
  279.             bne.b    _strcpy
  280.  
  281. _str_exit:    move.l    d0,a0
  282.             rts
  283.  
  284.  
  285. strcmp:        REPT 7
  286.             move.b    (a0)+,d0
  287.             beq.b    _strcend
  288.             cmp.b    (a1)+,d0
  289.             bne.b    _str_ne
  290.             ENDM
  291.  
  292.             move.b    (a0)+,d0
  293.             beq.b    _strcend
  294.             cmp.b    (a1)+,d0
  295.             beq.b    strcmp
  296.  
  297. _str_ne:    bcs.b    _str_lt
  298.             moveq.l    #1,D0
  299.             rts
  300.  
  301. _str_lt:    moveq.l    #-1,D0
  302.             rts
  303.  
  304. _strcend:    tst.b    (a1)
  305.             bne.b    _str_lt
  306.  
  307.             moveq.l    #0,D0
  308.             rts
  309.  
  310.  
  311. strlen:        move.l    a0,a1
  312.  
  313. _strlen:    REPT 7
  314.             tst.b    (a0)+
  315.             beq.b    _strlend
  316.             ENDM
  317.             
  318.             tst.b    (a0)+
  319.             bne.b    _strlen
  320.  
  321. _strlend:    move.l    a0,d0
  322.             sub.l    a1,d0
  323.             subq.l    #1,d0
  324.             rts
  325.  
  326.  
  327. strchr:        move.b    (a0)+,d1
  328.             beq.s    _sch_exit
  329.  
  330.             cmp.b    d1,d0
  331.             bne.s    strchr
  332.  
  333.             subq.w    #1,a0
  334.             rts
  335.  
  336. _sch_exit:    suba.l    a0,a0
  337.             rts
  338.  
  339.  
  340. get_fname:    move.l    a0,a1
  341.  
  342.             move.b    #'\',d1
  343.             move.b    #'/',d2
  344.  
  345. _gf_loop:    move.b    (a1)+,d0
  346.             beq.s    _gf_exit
  347.  
  348.             cmp.b    d1,d0
  349.             beq.s    _gf_set
  350.  
  351.             cmp.b    d2,d0
  352.             beq.s    _gf_set
  353.  
  354.             cmp.b    #':',d0
  355.             bne.s    _gf_loop
  356.  
  357. _gf_set:    movea.l    a1,a0
  358.             bra.s    _gf_loop
  359.  
  360. _gf_exit:    rts
  361.  
  362.  
  363. backpath:    bsr.s    get_fname
  364.             clr.b    (a0)
  365.             rts
  366.  
  367.  
  368. make_tree:    movem.l D3-D7/A2-A6,-(SP)
  369.             lea        -36(SP),SP
  370.  
  371.             lea        heap+2,A3    ; &heap[1]
  372.             clr.w   (A3)        ; heap[1] = 0
  373.             lea        heapsize,A4
  374.             movea.l 80(SP),A5    ; codeparm
  375.  
  376.             move.w  D0,D3        ; nparm
  377.             move.w  D3,D4        ; avail
  378.             move.w  D4,n        ; n
  379.             move.l  A0,freq        ; freqparm
  380.             move.l  A1,len        ; lenparm
  381.  
  382.             moveq.l    #0,D1        ; heapsize = 0
  383.  
  384.             subq.w    #1,D0
  385.             bmi.s    _m_no_for_i
  386.  
  387.             moveq.l    #0,D2
  388.             moveq.l    #0,D5        ; i = 0
  389.             move.l    A3,A6        ; &heap[1]
  390.  
  391. _m_for_i:    move.b    D2,(A1)+    ; len[i] = 0
  392.             tst.w    (A0)+        ; freq[i] ?
  393.             beq.s   _m_next_i
  394.  
  395.             addq.w  #1,D1
  396.             move.w  D5,(A6)+
  397.  
  398. _m_next_i:     addq.w    #1,D5
  399.             dbra    D0,_m_for_i
  400.  
  401. _m_no_for_i:move.w    D1,(A4)
  402.  
  403.             subq.w    #2,D1    ; heapsize<2 ?
  404.              bge.s   hs_ge_2
  405.  
  406.             move.w  (A3),D0
  407.             move.w    D0,D1
  408.             add.w   D1,D1
  409.             clr.w   0(A5,D1.w)
  410.  
  411.             lea        36(SP),SP
  412.             movem.l (SP)+,D3-D7/A2-A6
  413.             rts
  414.  
  415. hs_ge_2:    move.w    (A4),D5
  416.             moveq.l    #1,D6
  417.             asr.w    D6,D5    ; i = heapsize>>1
  418.             bra.s    down_h_next
  419.  
  420. down_h:        move.w    D5,D0
  421.             movem.l    D3-D5,-(SP)
  422.  
  423.             lea        heap,A0
  424.             movea.l freq,A1
  425.  
  426.             move.w  heapsize,D1
  427.             add.w    D1,D1
  428.  
  429.             add.w    D0,D0    ; i
  430.             lea.l    0(A0,D0.W),A2
  431.  
  432.             move.w  (A2),D2    ; k = heap[i]
  433.             move.w  D2,D3
  434.             add.w   D3,D3
  435.             move.w  0(A1,D3.w),D3    ; fk = freq[k]
  436.             move.w    D0,D4    ; j
  437.  
  438. _d_while1:    add.w    D4,D4
  439.  
  440.             cmp.w   D1,D4            ; j<=heapsize
  441.             bgt.s   _d_exit1
  442.             beq.s   _d_else1
  443.  
  444.             lea.l    0(A0,D4.W),A6
  445.             move.w    (A6)+,D5        ; heap[j]
  446.             add.w   D5,D5
  447.             move.w  0(A1,D5.w),D5    ; freq[heap[j]]
  448.             move.w  (A6),D0            ; heap[j+1]
  449.             add.w   D0,D0
  450.             cmp.w   0(A1,D0.w),D5    ; freq[heap[j+1]]
  451.             bls.s   _d_else1
  452.  
  453.             addq.w  #2,D4
  454.  
  455. _d_else1:    lea.l    0(A0,D4.W),A6
  456.             move.w    (A6),D5
  457.             move.w    D5,(A2)            ; heap[i] = heap[j]
  458.             add.w   D5,D5
  459.             cmp.w   0(A1,D5.w),D3    ; fk<=freq[heap[j]]
  460.             bls.s   _d_exit1
  461.  
  462.             move.l    A6,A2
  463.             bra.s    _d_while1
  464.  
  465. _d_exit1:     move.w  D2,(A2)            ; heap[i] = k
  466.  
  467.             movem.l (SP)+,D3-D5
  468.  
  469.             subq.w  #1,D5
  470.  
  471. down_h_next:cmp.w    D6,D5
  472.             bge.s   down_h
  473.  
  474. no_down_heap:
  475.             move.l  A5,sortptr
  476.  
  477. do_heap:    move.w    (A3),D5
  478.             cmp.w   n(pc),D5            ; i<n
  479.             bge.s   i_ge_n
  480.  
  481.             movea.l sortptr(pc),A0
  482.             move.w  D5,(A0)+
  483.             move.l    A0,sortptr            ; *sortptr++ = i
  484.  
  485. i_ge_n:        move.w    (A4),D0
  486.             add.w   D0,D0
  487.             move.w  -2(A3,D0.w),(A3)    ; heap[1] = heap[heapsize--]
  488.             subq.w  #1,(A4)
  489.  
  490.             movem.l    D3-D5,-(SP)
  491.  
  492.             lea        heap,A0
  493.             movea.l freq,A1
  494.  
  495.             move.w  heapsize,D1
  496.             add.w    D1,D1
  497.  
  498.             lea.l    2(A0),A2        ; downheap(1)
  499.  
  500.             move.w  (A2),D2            ; k = heap[i]
  501.             move.w  D2,D3
  502.             add.w   D3,D3
  503.             move.w  0(A1,D3.w),D3    ; fk = freq[k]
  504.             moveq.l    #4,D4    ; j
  505.  
  506. _d_while2:    cmp.w   D1,D4            ; j<=heapsize
  507.             bgt.s   _d_exit2
  508.             beq.s   _d_else2
  509.  
  510.             lea.l    0(A0,D4.W),A6
  511.             move.w    (A6)+,D5        ; heap[j]
  512.             add.w   D5,D5
  513.             move.w  0(A1,D5.w),D5    ; freq[heap[j]]
  514.             move.w  (A6),D0            ; heap[j+1]
  515.             add.w   D0,D0
  516.             cmp.w   0(A1,D0.w),D5    ; freq[heap[j+1]]
  517.             bls.s   _d_else2
  518.  
  519.             addq.w  #2,D4
  520.  
  521. _d_else2:    lea.l    0(A0,D4.W),A6
  522.             move.w    (A6),D5
  523.             move.w    D5,(A2)            ; heap[i] = heap[j]
  524.             add.w   D5,D5
  525.             cmp.w   0(A1,D5.w),D3    ; fk<=freq[heap[j]]
  526.             bls.s   _d_exit2
  527.  
  528.             move.l    A6,A2
  529.             add.w    D4,D4
  530.             bra.s    _d_while2
  531.  
  532. _d_exit2:     move.w  D2,(A2)            ; heap[i] = k
  533.  
  534.             movem.l (SP)+,D3-D5
  535.  
  536.             move.w  (A3),D6
  537.             cmp.w   n(pc),D6        ; j<n ?
  538.             bge.s   j_ge_n
  539.  
  540.             movea.l sortptr,A0
  541.             move.w  D6,(A0)+
  542.             move.l  A0,sortptr            ; *sortptr++ = j
  543.  
  544. j_ge_n:        move.w    D4,D7    ; k = avail
  545.             addq.w  #1,D4    ; avail++
  546.  
  547.             movea.l freq,A0
  548.  
  549.             move.w  D5,D0
  550.             add.w   D0,D0
  551.             move.w  0(A0,D0.w),D1    ; freq[i]
  552.             move.w  D6,D2
  553.             add.w   D2,D2
  554.             add.w   0(A0,D2.w),D1    ; freq[j]
  555.             move.w  D7,D0
  556.             add.w   D0,D0
  557.             move.w  D1,0(A0,D0.w)    ; freq[k] = freq[i] + freq[j]
  558.  
  559.             move.w  D7,(A3)            ; heap[1] = k
  560.  
  561.             movem.l    D3-D5,-(SP)
  562.  
  563.             lea        heap,A0
  564.             movea.l freq,A1
  565.  
  566.             move.w  heapsize,D1
  567.             add.w    D1,D1
  568.  
  569.             lea.l    2(A0),A2        ; downheap(1)
  570.  
  571.             move.w  (A2),D2            ; k = heap[i]
  572.             move.w  D2,D3
  573.             add.w   D3,D3
  574.             move.w  0(A1,D3.w),D3    ; fk = freq[k]
  575.             moveq.l    #4,D4    ; j
  576.  
  577. _d_while3:    cmp.w   D1,D4            ; j<=heapsize
  578.             bgt.s   _d_exit3
  579.             beq.s   _d_else3
  580.  
  581.             lea.l    0(A0,D4.W),A6
  582.             move.w    (A6)+,D5        ; heap[j]
  583.             add.w   D5,D5
  584.             move.w  0(A1,D5.w),D5    ; freq[heap[j]]
  585.             move.w  (A6),D0            ; heap[j+1]
  586.             add.w   D0,D0
  587.             cmp.w   0(A1,D0.w),D5    ; freq[heap[j+1]]
  588.             bls.s   _d_else3
  589.  
  590.             addq.w  #2,D4
  591.  
  592. _d_else3:    lea.l    0(A0,D4.W),A6
  593.             move.w    (A6),D5
  594.             move.w    D5,(A2)            ; heap[i] = heap[j]
  595.             add.w   D5,D5
  596.             cmp.w   0(A1,D5.w),D3    ; fk<=freq[heap[j]]
  597.             bls.s   _d_exit3
  598.  
  599.             move.l    A6,A2
  600.             add.w    D4,D4
  601.             bra.s    _d_while3
  602.  
  603. _d_exit3:     move.w  D2,(A2)            ; heap[i] = k
  604.  
  605.             movem.l (SP)+,D3-D5
  606.  
  607.             move.w    D7,D0
  608.             add.w   D0,D0
  609.             lea        left,A0
  610.             move.w  D5,0(A0,D0.w)    ; left[i] = k
  611.             lea        right,A1
  612.             move.w  D6,0(A1,D0.w)    ; right[i] = k
  613.  
  614.             cmpi.w  #1,(A4)            ; heapsize>1 ?
  615.             bgt        do_heap
  616.  
  617.             move.l  A5,sortptr        ; sortptr = codeparm
  618.  
  619.             move.w  D7,D0
  620.             bsr        make_len        ; make_len(k)
  621.  
  622.             lea.l    2(SP),A0        ; &start[1]
  623.             lea.l    len_cnt+2,A1
  624.  
  625.             moveq.l    #0,D1
  626.             moveq.l #3,D0
  627.             move.w    D1,(A0)+            ; start[1] = 0
  628.  
  629. for_start:    REPT    4
  630.             add.w    (A1)+,D1        ; start[i] + len_cnt[i]
  631.             add.w    D1,D1
  632.             move.w    D1,(A0)+
  633.             ENDM
  634.             dbra    D0,for_start
  635.  
  636.             moveq.l    #0,D1
  637.             move.l    len,A2
  638.             bra.s    next_i
  639.  
  640. for_i:        move.b  (A2)+,D1
  641.             add.w   D1,D1
  642.             lea.l    0(SP,D1.W),A0
  643.             move.w  (A0),(A5)+        ; codeparm[i] = start[lenparm[i]]
  644.             addq.w  #1,(A0)
  645. next_i:        dbra    d3,for_i
  646.  
  647.             move.w  D7,D0
  648.             lea           36(SP),SP
  649.             movem.l (SP)+,D3-D7/A2-A6
  650.             rts
  651.  
  652.  
  653. count_len:    cmp.w    n(pc),d0
  654.             bge.b    _i_ge_n
  655.  
  656.             move.w    depth(pc),d0
  657.             cmp.w    #16,d0
  658.             bge.b    _ge_16
  659.  
  660.             add.w    d0,d0
  661.             lea.l    len_cnt,a0
  662.             addq.w    #1,(a0,d0.w)
  663.             rts
  664.  
  665. _ge_16:        addq.w    #1,len_cnt+32
  666.             rts
  667.  
  668. _i_ge_n:    move.w    d3,-(sp)
  669.             lea.l    depth(pc),a1
  670.             addq.w    #1,(a1)
  671.  
  672.             move.w    d0,d3
  673.             add.w    d3,d3
  674.  
  675.             lea.l    left,a0
  676.             move.w    (a0,d3.w),d0
  677.             bsr.b    count_len
  678.  
  679.             lea.l    right,a0
  680.             move.w    (a0,d3.w),d0
  681.             bsr.b    count_len
  682.  
  683.             subq.w    #1,(a1)
  684.             move.w    (sp)+,d3
  685.             rts
  686.  
  687.  
  688. sortptr:    DC.L    0
  689. blkcnt:        DC.W    0
  690. depth:        DC.W    0
  691. n:            DC.W    0
  692. star:        DC.B    0,'*'
  693. flg_n:        DC.B    0
  694.  
  695.             EVEN
  696.             END
  697.